ajustes de metodos

Author: eriqueserpro

analysis_options.yaml

@@ -24,7 +24,7 @@ linter:
   # `// ignore_for_file: name_of_lint` syntax on the line or in the file
   # producing the lint.
   rules:
-    # avoid_print: false  # Uncomment to disable the `avoid_print` rule
+    avoid_print: false 
     # prefer_single_quotes: true  # Uncomment to enable the `prefer_single_quotes` rule
 # Additional information about this file can be found at
 # https://dart.dev/guides/language/analysis-options

lib/askar/askar_native_functions.dart

@@ -401,10 +401,10 @@ typedef AskarKeyDeriveEcdh1puNative = Int32 Function(
   NativeLocalKeyHandle ephem_key,
   NativeLocalKeyHandle sender_key,
   NativeLocalKeyHandle recip_key,
-  Pointer<NativeByteBuffer> alg_id,
-  Pointer<NativeByteBuffer> apu,
-  Pointer<NativeByteBuffer> apv,
-  Pointer<NativeByteBuffer> cc_tag,
+  NativeByteBuffer alg_id,
+  NativeByteBuffer apu,
+  NativeByteBuffer apv,
+  NativeByteBuffer cc_tag,
   Int8 receive,
   Pointer<NativeLocalKeyHandle> out,
 );
@@ -414,10 +414,10 @@ final int Function(
   LocalKeyHandle ephem_key,
   LocalKeyHandle sender_key,
   LocalKeyHandle recip_key,
-  Pointer<NativeByteBuffer> alg_id,
-  Pointer<NativeByteBuffer> apu,
-  Pointer<NativeByteBuffer> apv,
-  Pointer<NativeByteBuffer> cc_tag,
+  NativeByteBuffer alg_id,
+  NativeByteBuffer apu,
+  NativeByteBuffer apv,
+  NativeByteBuffer cc_tag,
   int receive,
   Pointer<NativeLocalKeyHandle> out,
 ) nativeAskarKeyDeriveEcdh1pu = nativeLib
@@ -576,13 +576,13 @@ final int Function(
 
 typedef AskarKeyFromPublicBytesNative = Int32 Function(
   Pointer<Utf8> alg,
-  Pointer<NativeByteBuffer> public_,
+  NativeByteBuffer public_,
   Pointer<NativeLocalKeyHandle> out,
 );
 
 final int Function(
   Pointer<Utf8> alg,
-  Pointer<NativeByteBuffer> public_,
+  NativeByteBuffer public_,
   Pointer<NativeLocalKeyHandle> out,
 ) nativeAskarKeyFromPublicBytes = nativeLib
     .lookup<NativeFunction<AskarKeyFromPublicBytesNative>>('askar_key_from_public_bytes')

lib/askar/askar_utils.dart

@@ -11,7 +11,11 @@ Pointer<NativeByteBuffer> stringToByteBuffer(String value) {
   return bytesListToByteBuffer(utf8.encode(value));
 }
 
-Pointer<NativeByteBuffer> bytesListToByteBuffer(Uint8List bytesList) {
+Pointer<NativeByteBuffer> bytesListToByteBuffer(Uint8List? bytesList) {
+  if (bytesList == null) {
+    return calloc<NativeByteBuffer>();
+  }
+
   Pointer<Uint8> dataPointer = calloc<Uint8>(bytesList.length);
 
   for (int i = 0; i < bytesList.length; i++) {

lib/askar/askar_wrapper.dart

@@ -12,6 +12,7 @@ import 'package:import_so_libaskar/askar/enums/askar_key_algorithm.dart';
 import 'package:import_so_libaskar/askar/enums/askar_key_backend.dart';
 import 'package:import_so_libaskar/askar/enums/askar_signature_algorithm.dart';
 import 'package:import_so_libaskar/askar/enums/askar_store_key_method.dart';
+import 'package:import_so_libaskar/askar/exceptions/exceptions.dart';
 
 import 'askar_native_functions.dart';
 import 'askar_utils.dart';
@@ -26,6 +27,13 @@ final class AskarResult<T> {
   String toString() {
     return "AskarResult($errorCode, $value)";
   }
+
+  T getValueOrException() {
+    if (errorCode == ErrorCode.success) {
+      return value;
+    }
+    throw AskarErrorCodeException(errorCode);
+  }
 }
 
 typedef LocalKeyHandle = int;
@@ -211,8 +219,8 @@ AskarResult<String> askarStringListGetItem(StringListHandle handle, int index) {
 }
 
 AskarResult<Uint8List> askarKeyAeadDecrypt(
-    LocalKeyHandle handle, Uint8List ciphertext, Uint8List nonce, Uint8List tag,
-    {Uint8List? aad}) {
+    LocalKeyHandle handle, Uint8List ciphertext, Uint8List nonce,
+    {Uint8List? tag, Uint8List? aad}) {
   aad ??= Uint8List(0);
 
   Pointer<NativeByteBuffer> ciphertextPtr = bytesListToByteBuffer(ciphertext);
@@ -421,36 +429,54 @@ ErrorCode askarKeyCryptoBoxSealOpen(
   return ErrorCode.fromInt(result);
 }
 
-ErrorCode askarKeyDeriveEcdh1pu(
-  String alg,
-  LocalKeyHandle ephemKey,
+AskarResult<LocalKeyHandle> askarKeyDeriveEcdh1pu(
+  KeyAlgorithm algorithm,
+  LocalKeyHandle ephemeralKey,
   LocalKeyHandle senderKey,
-  LocalKeyHandle recipKey,
-  Pointer<NativeByteBuffer> algId,
-  Pointer<NativeByteBuffer> apu,
-  Pointer<NativeByteBuffer> apv,
-  Pointer<NativeByteBuffer> ccTag,
-  int receive,
-  Pointer<NativeLocalKeyHandle> out,
+  LocalKeyHandle recipientKey,
+  Uint8List algId,
+  Uint8List apu,
+  Uint8List apv,
+  Uint8List ccTag,
+  bool receive,
 ) {
-  final algPointer = alg.toNativeUtf8();
+  Pointer<NativeLocalKeyHandle> outPtr = calloc<NativeLocalKeyHandle>();
+
+  final algPointer = algorithm.value.toNativeUtf8();
+  final algIdByteBufferPtr = bytesListToByteBuffer(algId);
+  final apuByteBufferPtr = bytesListToByteBuffer(apu);
+  final apvByteBufferPtr = bytesListToByteBuffer(apv);
+  final ccTagByteBufferPtr = bytesListToByteBuffer(ccTag);
 
-  final result = nativeAskarKeyDeriveEcdh1pu(
+  final funcResult = nativeAskarKeyDeriveEcdh1pu(
     algPointer,
-    ephemKey,
+    ephemeralKey,
     senderKey,
-    recipKey,
-    algId,
-    apu,
-    apv,
-    ccTag,
-    receive,
-    out,
+    recipientKey,
+    algIdByteBufferPtr.ref,
+    apuByteBufferPtr.ref,
+    apvByteBufferPtr.ref,
+    ccTagByteBufferPtr.ref,
+    boolToInt(receive),
+    outPtr,
   );
 
+  final errorCode = ErrorCode.fromInt(funcResult);
+
+  LocalKeyHandle value = (errorCode == ErrorCode.success ? outPtr.value : 0);
+
+  calloc.free(algIdByteBufferPtr.ref.data);
+  calloc.free(algIdByteBufferPtr);
+  calloc.free(apuByteBufferPtr.ref.data);
+  calloc.free(apuByteBufferPtr);
+  calloc.free(apvByteBufferPtr.ref.data);
+  calloc.free(apvByteBufferPtr);
+  calloc.free(ccTagByteBufferPtr.ref.data);
+  calloc.free(ccTagByteBufferPtr);
   calloc.free(algPointer);
+  calloc.free(outPtr);
 
-  return ErrorCode.fromInt(result);
+  return AskarResult<LocalKeyHandle>(errorCode, value);
 }
 
 AskarResult<LocalKeyHandle> askarKeyDeriveEcdhEs(
@@ -632,22 +658,31 @@ ErrorCode askarKeyFromKeyExchange(
   return ErrorCode.fromInt(result);
 }
 
-ErrorCode askarKeyFromPublicBytes(
-  String alg,
-  Pointer<NativeByteBuffer> public_,
-  Pointer<NativeLocalKeyHandle> out,
+AskarResult<LocalKeyHandle> askarKeyFromPublicBytes(
+  KeyAlgorithm algorithm,
+  Uint8List publicBytes,
 ) {
-  final algPointer = alg.toNativeUtf8();
+  Pointer<IntPtr> localKeyHandlePtr = calloc<IntPtr>();
+
+  final algPointer = algorithm.value.toNativeUtf8();
+  final byteBufferPointer = bytesListToByteBuffer(publicBytes);
 
-  final result = nativeAskarKeyFromPublicBytes(
+  final funcResult = nativeAskarKeyFromPublicBytes(
     algPointer,
-    public_,
-    out,
+    byteBufferPointer.ref,
+    localKeyHandlePtr,
   );
 
+  final errorCode = ErrorCode.fromInt(funcResult);
+
+  final localKeyHandle = (errorCode == ErrorCode.success) ? localKeyHandlePtr.value : 0;
+
   calloc.free(algPointer);
+  calloc.free(localKeyHandlePtr);
+  calloc.free(byteBufferPointer.ref.data);
+  calloc.free(byteBufferPointer);
 
-  return ErrorCode.fromInt(result);
+  return AskarResult<LocalKeyHandle>(errorCode, localKeyHandle);
 }
 
 AskarResult<LocalKeyHandle> askarKeyFromSecretBytes(
@@ -804,16 +839,22 @@ AskarResult<String> askarKeyGetJwkThumbprint(
   return AskarResult<String>(errorCode, value);
 }
 
-ErrorCode askarKeyGetPublicBytes(
-  LocalKeyHandle handle,
-  Pointer<NativeSecretBuffer> out,
-) {
-  final result = nativeAskarKeyGetPublicBytes(
+AskarResult<Uint8List> askarKeyGetPublicBytes(LocalKeyHandle handle) {
+  Pointer<NativeSecretBuffer> secretBufferPtr = calloc<NativeSecretBuffer>();
+
+  final funcResult = nativeAskarKeyGetPublicBytes(
     handle,
-    out,
+    secretBufferPtr,
   );
 
-  return ErrorCode.fromInt(result);
+  final errorCode = ErrorCode.fromInt(funcResult);
+
+  final value = Uint8List.fromList(secretBufferToBytesList(secretBufferPtr.ref));
+
+  calloc.free(secretBufferPtr.ref.data);
+  calloc.free(secretBufferPtr);
+
+  return AskarResult<Uint8List>(errorCode, value);
 }
 
 AskarResult<Uint8List> askarKeyGetSecretBytes(LocalKeyHandle handle) {
@@ -867,12 +908,8 @@ AskarResult<Uint8List> askarKeySignMessage(
 }
 
 AskarResult<LocalKeyHandle> askarKeyUnwrapKey(
-  LocalKeyHandle handle,
-  KeyAlgorithm algorithm,
-  Uint8List ciphertext,
-  Uint8List nonce,
-  Uint8List tag,
-) {
+    LocalKeyHandle handle, KeyAlgorithm algorithm, Uint8List ciphertext,
+    {Uint8List? nonce, Uint8List? tag}) {
   Pointer<NativeLocalKeyHandle> out = calloc<NativeLocalKeyHandle>();
 
   final algPtr = algorithm.value.toNativeUtf8();
@@ -941,14 +978,12 @@ AskarResult<bool> askarKeyVerifySignature(
 }
 
 AskarResult<AskarEncryptedBuffer> askarKeyWrapKey(
-  LocalKeyHandle handle,
-  LocalKeyHandle other,
-  Uint8List nonce,
-) {
-  final byteBufferPointer = bytesListToByteBuffer(nonce);
-
+    LocalKeyHandle handle, LocalKeyHandle other,
+    {Uint8List? nonce}) {
   Pointer<NativeEncryptedBuffer> encryptedBufferPtr = calloc<NativeEncryptedBuffer>();
 
+  final byteBufferPointer = bytesListToByteBuffer(nonce);
+
   final errorCode = ErrorCode.fromInt(nativeAskarKeyWrapKey(
     handle,
     other,

lib/askar/crypto/askar_encrypted_buffer.dart

@@ -45,5 +45,7 @@ AskarEncryptedBuffer readNativeEncryptedBuffer(NativeEncryptedBuffer encryptedBu
   int tagPos = encryptedBuffer.tag_pos;
 
   return AskarEncryptedBuffer(
-      secretBufferToBytesList(encryptedBuffer.buffer), tagPos, noncePos);
+      Uint8List.fromList(secretBufferToBytesList(encryptedBuffer.buffer)),
+      tagPos,
+      noncePos);
 }

lib/askar/crypto/askar_jwk.dart

@@ -0,0 +1,40 @@
+import 'dart:convert';
+import 'dart:typed_data';
+
+class AskarJwk {
+  final String kty;
+  final String crv;
+  final String x;
+  final String? d;
+  final String? y;
+
+  AskarJwk({required this.kty, required this.crv, required this.x, this.d, this.y});
+
+  factory AskarJwk.fromJson(Map<String, dynamic> json) {
+    return AskarJwk(
+      kty: json['kty'],
+      crv: json['crv'],
+      x: json['x'],
+      d: json['d'],
+      y: json['y'],
+    );
+  }
+
+  factory AskarJwk.fromString(String str) {
+    return AskarJwk.fromJson(jsonDecode(str));
+  }
+
+  Uint8List toUint8Array() {
+    return Uint8List.fromList(utf8.encode(jsonEncode(toJson())));
+  }
+
+  Map<String, dynamic> toJson() {
+    return {
+      'kty': kty,
+      'crv': crv,
+      'x': x,
+      'd': d,
+      'y': y,
+    };
+  }
+}