Line data    Source code

       1              : // ignore_for_file: deprecated_member_use
       2              : // ignoring the elementAt deprecation because this would make the SDK
       3              : // incompatible with older flutter versions than 3.19.0 or dart 3.3.0
       4              : 
       5              : import 'dart:async';
       6              : import 'dart:ffi';
       7              : import 'dart:typed_data';
       8              : 
       9              : import 'package:ffi/ffi.dart';
      10              : 
      11              : import 'package:matrix/src/utils/crypto/ffi.dart';
      12              : 
      13              : abstract class Hash {
      14            4 :   Hash._(this.ptr);
      15              :   Pointer<NativeType> ptr;
      16              : 
      17            2 :   FutureOr<Uint8List> call(Uint8List data) {
      18            6 :     final outSize = EVP_MD_size(ptr);
      19            4 :     final mem = malloc.call<Uint8>(outSize + data.length);
      20            2 :     final dataMem = mem.elementAt(outSize);
      21              :     try {
      22            6 :       dataMem.asTypedList(data.length).setAll(0, data);
      23           12 :       EVP_Digest(dataMem, data.length, mem, nullptr, ptr, nullptr);
      24            4 :       return Uint8List.fromList(mem.asTypedList(outSize));
      25              :     } finally {
      26            2 :       malloc.free(mem);
      27              :     }
      28              :   }
      29              : }
      30              : 
      31            0 : final Hash sha1 = _Sha1();
      32            6 : final Hash sha256 = _Sha256();
      33            6 : final Hash sha512 = _Sha512();
      34              : 
      35              : class _Sha1 extends Hash {
      36            0 :   _Sha1() : super._(EVP_sha1());
      37              : }
      38              : 
      39              : class _Sha256 extends Hash {
      40            8 :   _Sha256() : super._(EVP_sha256());
      41              : }
      42              : 
      43              : class _Sha512 extends Hash {
      44            8 :   _Sha512() : super._(EVP_sha512());
      45              : }
      46              : 
      47              : abstract class Cipher {
      48            9 :   Cipher._();
      49              :   Pointer<NativeType> getAlg(int keysize);
      50            9 :   FutureOr<Uint8List> encrypt(Uint8List input, Uint8List key, Uint8List iv) {
      51           27 :     final alg = getAlg(key.length * 8);
      52              :     final mem = malloc
      53           54 :         .call<Uint8>(sizeOf<IntPtr>() + key.length + iv.length + input.length);
      54            9 :     final lenMem = mem.cast<IntPtr>();
      55            9 :     final keyMem = mem.elementAt(sizeOf<IntPtr>());
      56           18 :     final ivMem = keyMem.elementAt(key.length);
      57           18 :     final dataMem = ivMem.elementAt(iv.length);
      58              :     try {
      59           27 :       keyMem.asTypedList(key.length).setAll(0, key);
      60           27 :       ivMem.asTypedList(iv.length).setAll(0, iv);
      61           27 :       dataMem.asTypedList(input.length).setAll(0, input);
      62           18 :       final ctx = EVP_CIPHER_CTX_new();
      63           27 :       EVP_EncryptInit_ex(ctx, alg, nullptr, keyMem, ivMem);
      64           27 :       EVP_EncryptUpdate(ctx, dataMem, lenMem, dataMem, input.length);
      65           27 :       EVP_EncryptFinal_ex(ctx, dataMem.elementAt(lenMem.value), lenMem);
      66           18 :       EVP_CIPHER_CTX_free(ctx);
      67           27 :       return Uint8List.fromList(dataMem.asTypedList(input.length));
      68              :     } finally {
      69            9 :       malloc.free(mem);
      70              :     }
      71              :   }
      72              : }
      73              : 
      74           27 : final Cipher aesCtr = _AesCtr();
      75              : 
      76              : class _AesCtr extends Cipher {
      77           18 :   _AesCtr() : super._();
      78              : 
      79            9 :   @override
      80              :   Pointer<NativeType> getAlg(int keysize) {
      81              :     switch (keysize) {
      82            9 :       case 128:
      83            0 :         return EVP_aes_128_ctr();
      84            9 :       case 256:
      85           18 :         return EVP_aes_256_ctr();
      86              :       default:
      87            0 :         throw ArgumentError('invalid key size');
      88              :     }
      89              :   }
      90              : }
      91              : 
      92            2 : FutureOr<Uint8List> pbkdf2(
      93              :   Uint8List passphrase,
      94              :   Uint8List salt,
      95              :   Hash hash,
      96              :   int iterations,
      97              :   int bits,
      98              : ) {
      99            2 :   final outLen = bits ~/ 8;
     100            8 :   final mem = malloc.call<Uint8>(passphrase.length + salt.length + outLen);
     101            4 :   final saltMem = mem.elementAt(passphrase.length);
     102            4 :   final outMem = saltMem.elementAt(salt.length);
     103              :   try {
     104            6 :     mem.asTypedList(passphrase.length).setAll(0, passphrase);
     105            6 :     saltMem.asTypedList(salt.length).setAll(0, salt);
     106            4 :     PKCS5_PBKDF2_HMAC(
     107              :       mem,
     108            2 :       passphrase.length,
     109              :       saltMem,
     110            2 :       salt.length,
     111              :       iterations,
     112            2 :       hash.ptr,
     113              :       outLen,
     114              :       outMem,
     115              :     );
     116            4 :     return Uint8List.fromList(outMem.asTypedList(outLen));
     117              :   } finally {
     118            2 :     malloc.free(mem);
     119              :   }
     120              : }