Skip to content

Commit

Permalink
run dart format to increase pub score
Browse files Browse the repository at this point in the history
  • Loading branch information
@JannesNebendahl
JannesNebendahl committed Aug 28, 2024
1 parent fa0d7d6 commit 7851886
Show file tree
Hide file tree
Showing 23 changed files with 60,645 additions and 644 deletions.
3 changes: 3 additions & 0 deletions CHANGELOG.md
View file
Original file line number Diff line number Diff line change
@@ -1,3 +1,6 @@
## 1.0.2
- run `dart format` to increase pub score

## 1.0.1
- renamed example file to make it accessible for pub.dev
- fixed warnings to increase pub score
Expand Down
26 changes: 15 additions & 11 deletions example/dilithium_crypto_example.dart
View file
Original file line number Diff line number Diff line change
Expand Up @@ -4,15 +4,18 @@ import 'dart:typed_data';

import 'package:dilithium_crypto/dilithium_crypto.dart';

Uint8List randomSeed(){
Uint8List randomSeed() {
final random = Random.secure();
return Uint8List.fromList(List<int>.generate(Dilithium.SEEDBYTES, (_) => random.nextInt(256)));
return Uint8List.fromList(
List<int>.generate(Dilithium.SEEDBYTES, (_) => random.nextInt(256)));
}

void main() {
// generate key pair
final DilithiumKeyPair keyPair = Dilithium.generateKeyPair(DilithiumParameterSpec.LEVEL3, randomSeed()); // Level2 or Level5 can be used as well

final DilithiumKeyPair keyPair = Dilithium.generateKeyPair(
DilithiumParameterSpec.LEVEL3,
randomSeed()); // Level2 or Level5 can be used as well

// create signature
final Uint8List validMsg = utf8.encode("Valid Message");
final Uint8List signature = Dilithium.sign(keyPair.privateKey, validMsg);
Expand All @@ -30,19 +33,20 @@ void main() {
Uint8List publicKeyBytes = keyPair.publicKey.serialize();
Uint8List privateKeyBytes = keyPair.privateKey.serialize();

print("Private Key:"); print(privateKeyBytes);
print("\nPublic Key:"); print(publicKeyBytes);
print("Private Key:");
print(privateKeyBytes);
print("\nPublic Key:");
print(publicKeyBytes);

// recreate keys from byte representation
DilithiumPublicKey recreatedPublicKey = DilithiumPublicKey.deserialize(DilithiumParameterSpec.LEVEL3, publicKeyBytes);
DilithiumPrivateKey recreatedPrivateKey = DilithiumPrivateKey.deserialize(DilithiumParameterSpec.LEVEL3, privateKeyBytes);
DilithiumPublicKey recreatedPublicKey = DilithiumPublicKey.deserialize(
DilithiumParameterSpec.LEVEL3, publicKeyBytes);
DilithiumPrivateKey recreatedPrivateKey = DilithiumPrivateKey.deserialize(
DilithiumParameterSpec.LEVEL3, privateKeyBytes);

// prove that the recreated keys are working
final newMsg = utf8.encode("New Message");
final Uint8List newSignature = Dilithium.sign(recreatedPrivateKey, newMsg);
isValid = Dilithium.verify(recreatedPublicKey, newSignature, newMsg);
assert(isValid);
}



22 changes: 11 additions & 11 deletions integration_test/hash_and_sign_test.dart
View file
Original file line number Diff line number Diff line change
@@ -1,22 +1,22 @@

import 'dart:convert';
import 'dart:typed_data';
import 'dart:math';
import 'package:crypto/crypto.dart';
import 'package:dilithium_crypto/dilithium_crypto.dart';
import 'package:test/test.dart';

main(){
main() {
late DilithiumKeyPair keyPair;

setUpAll((){
setUpAll(() {
final random = Random.secure();
final seed = Uint8List.fromList(List<int>.generate(Dilithium.SEEDBYTES, (_) => random.nextInt(256)));
final seed = Uint8List.fromList(
List<int>.generate(Dilithium.SEEDBYTES, (_) => random.nextInt(256)));

keyPair = Dilithium.generateKeyPair(DilithiumParameterSpec.LEVEL3, seed);
});

test('Hash and Sign Paradigma', (){
test('Hash and Sign Paradigma', () {
String msg = "This is a long test message, longer than 32 bytes.";

// Sender:
Expand All @@ -28,11 +28,11 @@ main(){
// Receiver:
String receivedMsg = msg;
Uint8List receivedMsgBytes = utf8.encode(receivedMsg);
Uint8List generatedHashValue = Uint8List.fromList(sha256.convert(receivedMsgBytes).bytes);

bool isValid = Dilithium.verify(keyPair.publicKey, signature, generatedHashValue);
Uint8List generatedHashValue =
Uint8List.fromList(sha256.convert(receivedMsgBytes).bytes);

bool isValid =
Dilithium.verify(keyPair.publicKey, signature, generatedHashValue);
expect(isValid, isTrue); // --> the received message is unmodified
});


}
}
19 changes: 9 additions & 10 deletions integration_test/msg_setup_test.dart
View file
Original file line number Diff line number Diff line change
@@ -1,32 +1,32 @@

import 'dart:convert';
import 'dart:math';
import 'dart:typed_data';
import 'package:dilithium_crypto/dilithium_crypto.dart';
import 'package:test/test.dart';

void main(){
void main() {
late DilithiumKeyPair keyPair;

setUpAll((){
setUpAll(() {
final random = Random.secure();
final seed = Uint8List.fromList(List<int>.generate(Dilithium.SEEDBYTES, (_) => random.nextInt(256)));
final seed = Uint8List.fromList(
List<int>.generate(Dilithium.SEEDBYTES, (_) => random.nextInt(256)));

keyPair = Dilithium.generateKeyPair(DilithiumParameterSpec.LEVEL3, seed);
});

group('encode message as Uint8List', (){
group('encode message as Uint8List', () {
test('string msg', () {
String stringMsg = 'Hello World!';
Uint8List byteMsg = utf8.encode(stringMsg);

final signature = Dilithium.sign(keyPair.privateKey, byteMsg);
final isValid = Dilithium.verify(keyPair.publicKey, signature, byteMsg);

expect(isValid, isTrue);
expect(isValid, isTrue);
});

test('int msg', (){
test('int msg', () {
ByteData byteData = ByteData(8); // 8 bytes for int (int64)

int intMsg = 1234567890;
Expand All @@ -39,7 +39,7 @@ void main(){
expect(isValid, isTrue);
});

test('double msg', (){
test('double msg', () {
ByteData byteData = ByteData(8); // 8 bytes for double

double doubleMsg = 3.141592653589793;
Expand All @@ -52,5 +52,4 @@ void main(){
expect(isValid, isTrue);
});
});

}
}
75 changes: 42 additions & 33 deletions integration_test/package_usage_test.dart
View file
Original file line number Diff line number Diff line change
Expand Up @@ -4,118 +4,127 @@ import 'package:dilithium_crypto/dilithium_crypto.dart';
import 'package:test/test.dart';

void main() {
Uint8List randomSeed(){
Uint8List randomSeed() {
final random = Random.secure();
return Uint8List.fromList(List<int>.generate(Dilithium.SEEDBYTES, (_) => random.nextInt(256)));
return Uint8List.fromList(
List<int>.generate(Dilithium.SEEDBYTES, (_) => random.nextInt(256)));
}

void keygen(DilithiumParameterSpec spec){
void keygen(DilithiumParameterSpec spec) {
final keyPair = Dilithium.generateKeyPair(spec, randomSeed());

expect(keyPair.publicKey, isA<DilithiumPublicKey>());
expect(keyPair.privateKey, isA<DilithiumPrivateKey>());
}

void signAndVerify(DilithiumParameterSpec spec){
void signAndVerify(DilithiumParameterSpec spec) {
final keyPair = Dilithium.generateKeyPair(spec, randomSeed());
final altKeyPair = Dilithium.generateKeyPair(spec, randomSeed());

for(int msgLength = 0; msgLength < 10; msgLength++){
final message = Uint8List.fromList(List<int>.generate(msgLength, (_) => msgLength));
for (int msgLength = 0; msgLength < 10; msgLength++) {
final message =
Uint8List.fromList(List<int>.generate(msgLength, (_) => msgLength));

final signature = Dilithium.sign(keyPair.privateKey, message);

// Can verify with correct key
expect(Dilithium.verify(keyPair.publicKey, signature, message), isTrue);

// Cannot verify with incorrect key
expect(Dilithium.verify(altKeyPair.publicKey, signature, message), isFalse);
expect(
Dilithium.verify(altKeyPair.publicKey, signature, message), isFalse);

// Cannot verify with incorrect signature length
Uint8List toShortSignature = signature.sublist(0, signature.length - 1);
expect(Dilithium.verify(keyPair.publicKey, toShortSignature, message), isFalse);
expect(Dilithium.verify(keyPair.publicKey, toShortSignature, message),
isFalse);

// Can detect any bit-level modifications of the message
for(int modifiedByte=0; modifiedByte < msgLength; modifiedByte++){
for(int modifiedBit=0; modifiedBit < 8; modifiedBit++){
for (int modifiedByte = 0; modifiedByte < msgLength; modifiedByte++) {
for (int modifiedBit = 0; modifiedBit < 8; modifiedBit++) {
final modifiedMessage = message;
modifiedMessage[modifiedByte] ^= 1 << modifiedBit;

expect(Dilithium.verify(keyPair.publicKey, signature, modifiedMessage), isFalse);
expect(
Dilithium.verify(keyPair.publicKey, signature, modifiedMessage),
isFalse);
}
}
}
}

void useDeserializedKeys(DilithiumParameterSpec spec){
void useDeserializedKeys(DilithiumParameterSpec spec) {
final keyPair = Dilithium.generateKeyPair(spec, randomSeed());

final message = Uint8List.fromList([0xA0, 0x16, 0xC9, 0x94]);
final signature = Dilithium.sign(keyPair.privateKey, message);

// Verify with reconstructed public key
final serializedPublicKey = keyPair.publicKey.serialize();
final reconstructedPublicKey = DilithiumPublicKey.deserialize(spec, serializedPublicKey);
expect(Dilithium.verify(reconstructedPublicKey, signature, message), isTrue);
final reconstructedPublicKey =
DilithiumPublicKey.deserialize(spec, serializedPublicKey);
expect(
Dilithium.verify(reconstructedPublicKey, signature, message), isTrue);

// Sign with reconstructed private key
final serializedPrivateKey = keyPair.privateKey.serialize();
final reconstructedPrivateKey = DilithiumPrivateKey.deserialize(spec, serializedPrivateKey);
final reconstructedPrivateKey =
DilithiumPrivateKey.deserialize(spec, serializedPrivateKey);
final newMessage = Uint8List.fromList([0x1A, 0x2B, 0x3C, 0x4D]);
final newSignature = Dilithium.sign(reconstructedPrivateKey, newMessage);

// Verify with original public key
expect(Dilithium.verify(keyPair.publicKey, newSignature, newMessage), isTrue);
expect(
Dilithium.verify(keyPair.publicKey, newSignature, newMessage), isTrue);
}

group('Algorithm (Dilithium) usage', (){
group('Dilithium 2', (){
group('Algorithm (Dilithium) usage', () {
group('Dilithium 2', () {
final spec = DilithiumParameterSpec.LEVEL2;

test('D2 keygen',(){
test('D2 keygen', () {
keygen(spec);
});

test('D2 sign and verify',(){
test('D2 sign and verify', () {
signAndVerify(spec);
});

test('D2 use deserialized keys',(){
test('D2 use deserialized keys', () {
useDeserializedKeys(spec);
});
});
group('Dilithium 3', (){

group('Dilithium 3', () {
final spec = DilithiumParameterSpec.LEVEL3;

test('D3 keygen',(){
test('D3 keygen', () {
keygen(spec);
});

test('D3 sign and verify',(){
test('D3 sign and verify', () {
signAndVerify(spec);
});

test('D3 use deserialized keys',(){
test('D3 use deserialized keys', () {
useDeserializedKeys(spec);
});
});

group('Dilithium 5', (){
group('Dilithium 5', () {
final spec = DilithiumParameterSpec.LEVEL5;

test('D5 keygen',(){
test('D5 keygen', () {
keygen(spec);
});

test('D5 sign and verify',(){
test('D5 sign and verify', () {
signAndVerify(spec);
});

test('D5 use deserialized keys',(){
test('D5 use deserialized keys', () {
useDeserializedKeys(spec);
});
});
});

}
}
Loading

0 comments on commit 7851886

Please sign in to comment.